package com.example.jetpacktest.coroutine

import kotlinx.coroutines.*
import org.junit.Test
import java.lang.Exception

class CoroutineTest1 {

    suspend fun fun1(){
        GlobalScope.launch {
            delay(10 * 1000)
            println("fun1().....delay之后")
        }
    }

    suspend fun fun2(){
        GlobalScope.async {
            delay(10 * 1000)
            println("fun2().....delay之后")
        }.await()
    }

    @Test
    fun test1(){
        runBlocking {
            val job1 = launch {
                println("挂起前")
                //fun1是挂起函数（有suspend修饰符），但是fun1的很快就能执行完，也就是说马上就能恢复
                //执行到fun1时将job1挂起了，但是fun1很快就执行完了，因此job1很快又恢复了
                //fun1()

                //fun2也是挂起函数（有suspend修饰符），但是fun2执行的很慢
                //执行到fun2时将job1挂起了，但是fun2执行的很慢，10s才能执行完，也就是说10s之后job1才能恢复(resume)
                fun2()
                println("挂起后")
            }
            delay(1000)
            println("协程外....")
        }
    }


    suspend fun fun3(){
        println("fun3()....")
        throw Exception("自定义的异常")
    }


    @Test
    fun test2(){
        runBlocking {
            val job1 = launch {
                println("job1开始......")
                val job11 = launch {
                    fun3()
                    /*try{
                        fun3()
                    }catch (ex: Exception){
                        println(ex.message)
                    }*/
                }
                delay(5 * 1000)
                println("job1结束......")
            }
            delay(1000)
            println("job1的外面....")
        }
    }


    @Test
    fun test3(){
        runBlocking {
            val job1 = launch {
                println("job1开始.......")
                try{
                    async {
                        fun3()
                    }
                }catch (ex: Exception){
                    println("ex = " + ex.message)
                }

                delay(5000)
                println("job1结束.......")
            }
        }
    }

    suspend fun fun4(x: Int): Int{
        return withContext(Dispatchers.IO){
            delay(5000)
            if(x > 10){
                x * 5
            }else{
                throw Exception("自定义异常: x过小")
            }
        }
    }

    @Test
    fun test4(){
        runBlocking {
            launch {
                println("开始网络请求")
                try{
                    val res = fun4(12)
                    println("网络请求完成: $res")
                }catch (ex: Exception){
                    println("网络请求发生异常：${ex.message}")
                }
            }
            delay(1000)
            println("协程外部") //主要是测试是否阻塞了线程
        }
    }




}